/**
 * 同步服务模块 - 管理与手机端的数据同步
 */
import featureAbility from '@ohos.ability.featureAbility';
import prompt from '@system.prompt';
import * as api from './api.js';
import * as wordService from './wordService.js';
import storage from '@system.storage';

// 存储键
const SYNC_SETTINGS_KEY = 'sync_settings';
const PENDING_SYNC_KEY = 'pending_sync_data';

// 同步频率选项（以毫秒为单位）
const SYNC_FREQUENCY = {
    ON_LAUNCH: 'on_launch',    // 每次启动
    HOURLY: 'hourly',          // 每小时一次（3600000毫秒）
    DAILY: 'daily',            // 每天一次（86400000毫秒）
    MANUAL: 'manual'           // 仅手动同步
};

/**
 * 同步设置类型
 * @typedef {Object} SyncSettings
 * @property {string} frequency - 同步频率 ('on_launch', 'hourly', 'daily', 'manual')
 * @property {number} lastSyncTime - 最后同步时间戳
 */

/**
 * 获取同步设置
 * @returns {Promise<SyncSettings>} 同步设置
 */
export async function getSyncSettings() {
    try {
        const settingsStr = await storage.get({
            key: SYNC_SETTINGS_KEY,
            default: ''
        });
        
        if (settingsStr && settingsStr.trim() !== '') {
            return JSON.parse(settingsStr);
        }
        
        // 默认设置
        const defaultSettings = {
            frequency: SYNC_FREQUENCY.DAILY,
            lastSyncTime: 0
        };
        
        // 保存并返回默认设置
        await saveSyncSettings(defaultSettings);
        return defaultSettings;
    } catch (error) {
        console.error('获取同步设置失败:', error);
        
        // 返回默认设置
        return {
            frequency: SYNC_FREQUENCY.DAILY,
            lastSyncTime: 0
        };
    }
}

/**
 * 保存同步设置
 * @param {SyncSettings} settings - 同步设置
 */
export async function saveSyncSettings(settings) {
    try {
        await storage.set({
            key: SYNC_SETTINGS_KEY,
            value: JSON.stringify(settings)
        });
    } catch (error) {
        console.error('保存同步设置失败:', error);
    }
}

/**
 * 更改同步频率
 * @param {string} frequency - 同步频率
 */
export async function changeSyncFrequency(frequency) {
    try {
        const settings = await getSyncSettings();
        settings.frequency = frequency;
        await saveSyncSettings(settings);
        
        return {
            success: true,
            message: '同步频率已更新'
        };
    } catch (error) {
        console.error('更改同步频率失败:', error);
        
        return {
            success: false,
            message: '更改同步频率失败'
        };
    }
}

/**
 * 连接到手机端并同步数据
 * @returns {Promise<Object>} 同步结果
 */
export async function syncWithPhone() {
    try {
        // 检查网络连接
        const isNetworkConnected = await api.getNetworkStatus();
        
        if (!isNetworkConnected) {
            return {
                success: false,
                message: '网络连接失败，请检查网络'
            };
        }
        
        // 检查用户是否已登录
        const isAuthenticated = await api.isAuthenticated();
        
        if (!isAuthenticated) {
            return {
                success: false,
                message: '用户未登录，请先登录'
            };
        }
        
        // 1. 同步学习记录
        const historyStr = await storage.get({
            key: PENDING_SYNC_KEY,
            default: '[]'
        });
        
        const pendingRecords = JSON.parse(historyStr);
        
        // 如果有待同步的记录，则发送到服务器
        if (pendingRecords.length > 0) {
            try {
                const userId = await api.getUserId();
                
                // 批量提交学习记录
                await api.post('/api/words/sync', {
                    userId,
                    records: pendingRecords
                });
                
                // 清空待同步记录
                await storage.set({
                    key: PENDING_SYNC_KEY,
                    value: '[]'
                });
            } catch (syncError) {
                console.error('同步学习记录失败:', syncError);
                // 继续执行，即使学习记录同步失败
            }
        }
        
        // 2. 获取最新单词数据
        const dailyWordsResult = await wordService.getDailyStudyWords();
        
        // 3. 获取最新学习统计
        const statsResult = await wordService.getStudyStats();
        
        // 4. 更新同步设置
        const settings = await getSyncSettings();
        settings.lastSyncTime = Date.now();
        await saveSyncSettings(settings);
        
        // 返回同步结果
        return {
            success: true,
            message: '同步成功',
            newWordsCount: dailyWordsResult.newWords.length,
            reviewWordsCount: dailyWordsResult.reviewWords.length,
            stats: statsResult
        };
    } catch (error) {
        console.error('同步数据失败:', error);
        
        return {
            success: false,
            message: '同步失败，请稍后重试'
        };
    }
}

/**
 * 添加待同步的学习记录
 * @param {number} wordId - 单词ID
 * @param {boolean} isCorrect - 是否正确
 * @param {boolean} isNewWord - 是否为新词
 */
export async function addPendingSyncRecord(wordId, isCorrect, isNewWord) {
    try {
        // 获取现有待同步记录
        const recordsStr = await storage.get({
            key: PENDING_SYNC_KEY,
            default: '[]'
        });
        
        const records = JSON.parse(recordsStr);
        
        // 添加新记录
        records.push({
            wordId,
            isCorrect,
            isNewWord,
            timestamp: Date.now()
        });
        
        // 保存回存储
        await storage.set({
            key: PENDING_SYNC_KEY,
            value: JSON.stringify(records)
        });
    } catch (error) {
        console.error('添加待同步记录失败:', error);
    }
}

/**
 * 启动手机端应用
 * @returns {Promise<Object>} 启动结果
 */
export async function launchPhoneApp() {
    try {
        // 检查设备连接
        const isConnected = await checkDeviceConnection();
        
        if (!isConnected) {
            return {
                success: false,
                message: '未连接到手机'
            };
        }
        
        // 使用featureAbility打开手机应用
        // 注意：实际场景中可能需要更复杂的实现
        featureAbility.startAbility({
            want: {
                bundleName: 'com.applevacob.app',
                abilityName: 'MainActivity'
            }
        }, (error) => {
            if (error) {
                console.error('启动手机应用失败:', error);
                return {
                    success: false,
                    message: '启动手机应用失败'
                };
            }
        });
        
        return {
            success: true,
            message: '已启动手机应用'
        };
    } catch (error) {
        console.error('启动手机应用失败:', error);
        
        return {
            success: false,
            message: '启动手机应用失败'
        };
    }
}

/**
 * 检查设备连接状态
 * @returns {Promise<boolean>} 是否已连接
 */
export async function checkDeviceConnection() {
    // 实际场景中可能需要更复杂的实现
    // 这里简单地检查网络连接作为示例
    return await api.getNetworkStatus();
}

/**
 * 检查是否需要同步
 * @returns {Promise<boolean>} 是否需要同步
 */
export async function checkSyncNeeded() {
    try {
        const settings = await getSyncSettings();
        const lastSyncTime = settings.lastSyncTime || 0;
        const now = Date.now();
        
        // 检查是否有待同步的记录
        const pendingStr = await storage.get({
            key: PENDING_SYNC_KEY,
            default: '[]'
        });
        
        const pendingRecords = JSON.parse(pendingStr);
        
        if (pendingRecords.length > 0) {
            return true; // 有待同步记录，需要同步
        }
        
        // 根据同步频率决定
        switch (settings.frequency) {
            case SYNC_FREQUENCY.ON_LAUNCH:
                return true; // 每次启动都同步
                
            case SYNC_FREQUENCY.HOURLY:
                // 检查是否过去了一小时
                return (now - lastSyncTime) >= 3600000;
                
            case SYNC_FREQUENCY.DAILY:
                // 检查是否过去了一天
                return (now - lastSyncTime) >= 86400000;
                
            case SYNC_FREQUENCY.MANUAL:
                return false; // 仅手动同步
                
            default:
                return false;
        }
    } catch (error) {
        console.error('检查同步需求失败:', error);
        return false;
    }
}

// 导出同步频率常量
export const SyncFrequency = SYNC_FREQUENCY; 